package com.admin.service;

import java.util.ArrayList;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import com.admin.dao.AdminSchoolDao;
import com.common.model.College;
import com.common.model.Department;
import com.common.model.ProfBranch;
import com.common.model.Profession;

@Service
public class AdminSchoolService {
	@Autowired
	@Qualifier("adminSchoolDao")
	AdminSchoolDao dao;
	/**
	 * 读取所有的学院
	 * @return
	 */
	public ArrayList<College> getAllCollege(){
		return dao.getAllCollege();
	}
	
	/**
	 * 读取某学院下的所有系
	 * @param college_id 学院id
	 * @return 
	 */
	public ArrayList<Department>getDepsOfCollege(int clgId){
		if(clgId==0){
			return new ArrayList<Department>();
		}
		return dao.getDepsOfCollege(clgId);
	}
	
	/**
	 * 读取某系下的所有专业
	 * @param depId 系id
	 * @return
	 */
	public ArrayList<Profession>getProsOfDeps(int depId){
		if(depId==0){
			return new ArrayList<Profession>();
		}
		return dao.getProsOfDeps(depId);
	}
	/**
	 * 读取某专业下的所有专业方向
	 * @param proId
	 * @return
	 */
	public ArrayList<ProfBranch>getBranchesOfPro(int proId){
		if(proId==0){
			return new ArrayList<ProfBranch>();
		}
		return dao.getBranchesOfPro(proId);
	}
	/**
	 * 根据条件查询方向数据
	 * @param clgId 学院id
	 * @param depId 系id
	 * @param proId 专业id
	 * @param page 页码(从1开始)
	 * @return
	 */
	public ArrayList<ProfBranch> getBranchBy(int clgId,int depId,int proId, int page){
		if(page<1){
			page=1;
		}
		int start=(page-1)*10;
		if(clgId==0){
			return dao.getBranchesByAll(start);
		}else if(depId==0){
			return dao.getBranchesByClgId(start, clgId);
		} else if(proId==0){
			return dao.getBranchesByDepId(start, depId);
		}else{
			return dao.getBranchesByProId(start, proId);
		}
	}
	/**
	 * 条件查询所有专业方向数目
	 * @param clgId 学院id
	 * @param depId 系id
	 * @param proId 专业id
	 * @return
	 */
	public int getBranchCountBy(int clgId,int depId,int proId){
		if(clgId==0){
			return dao.getBranchesCountByAll();
		}else if(depId==0){
			return dao.getBranchesCountByClgId(clgId);
		} else if(proId==0){
			return dao.getBranchesCountByDepId(depId);
		}else{
			return dao.getBranchesCountByProId(proId);
		}
	}
	/**
	 * 根据专业方向id查询专业方向
	 * @param pbId 专业方向id
	 * @return
	 */
	public ProfBranch getProBranchByPbId(int pbId){
		if(pbId==0){
			return null;
		}
		return dao.getProBranchByPbId(pbId);
	}
	/**
	 * 根据专业id查询专业
	 * @param proId 专业id
	 * @return
	 */
	public Profession getProfessionByProId(int proId){
		return dao.getProfessionByProId(proId);
	}
	/**
	 * 修改方向信息
	 * @param pb
	 * @return
	 */
	public int updateProBranch(ProfBranch pb){
		return dao.updateProBranch(pb);
	}
	/**
	 * 删除某个专业方向
	 * @param pbId
	 * @return -1专业方向之下还有班级存留,-2 专业方向之下还有题目存留 0成功
	 */
	public int deleteProBranch(int pbId){
		if(dao.getClassCountOfBranch(pbId)>0){
			return -1;
		}
		if(dao.getProjectCountOfBranch(pbId)>0){
			return -2;
		}
		dao.deleteProBranch(pbId);
		return 0;
	}

	/**
	 * 增加一个专业方向
	 * @param pb
	 * @return
	 */
	public int insertProBranch(ProfBranch pb){
		//不重复添加相同no的专业方向
		if(dao.getBranchByBranchNo(pb.getNo())!=null){
			return -1;
		}
		try {
			dao.insertProBranch(pb);
		} catch (Exception e) {
			return -2;
		}
		return 0;
	}
	/**
	 * 根据方向编号查询方向
	 * @param no 专业编号
	 * @return
	 */
	public ProfBranch getBranchByBranchNo(int no){
		return dao.getBranchByBranchNo(no);
	}
	
	/**
	 * 根据条件查询专业
	 * @param clgId 学院id
	 * @param depId 系id
	 * @param page 页码(从1开始)
	 * @return
	 */
	public ArrayList<Profession> getProfessionBy(int clgId,int depId, int page){
		if(page<1){
			page=1;
		}
		int start=(page-1)*10;
		if(clgId==0){
			return dao.getProfessionsByAll(start);
		}else if(depId==0){
			return dao.getProfessionsByClgId(start, clgId);
		} else{
			return dao.getProfessionsByDepId(start, depId);
		}
	}
	/**
	 * 条件查询所有专业数目
	 * @param clgId 学院id
	 * @param depId 系id
	 * @return
	 */
	public int getProfessionCountBy(int clgId,int depId){
		if(clgId==0){
			return dao.getProfessionsCountByAll();
		}else if(depId==0){
			return dao.getProfessionsCountByClgId(clgId);
		} else{
			return dao.getProfessionsCountByDepId(depId);
		}
	}
	/**
	 * 通过系id查询系
	 * @param depId
	 * @return
	 */
	public Department getDepartmentByDepId(int depId){
		return dao.getDepartmentByDepId(depId);
	}
	/**
	 * 通过专业no查询专业
	 * @param proNo
	 * @return
	 */
	public Profession getProfessionByProNo(String proNo){
		return dao.getProfessionByProNo(proNo);
	}
	/**
	 * 修改一个专业
	 * @param pro
	 * @return
	 */
	public int updateProfession(Profession pro){
		return dao.updateProfession(pro);
	}
	/**
	 * 删除一个专业
	 * @param proId
	 * @return -1 专业下还有专业方向存在 0 成功
	 */
	public int deleteProfession(int proId){
		if(dao.getBranchesCountByProId(proId)>0){
			return -1;
		}
		dao.deleteProfession(proId);
		return 0;
	}
	/**
	 * 增加一个专业
	 * @param pro
	 * @return -1 专业编号重复 -2,参数错误
	 */
	public int insertProfession(Profession pro){
		if(dao.getProfessionByProNo(pro.getNo())!=null){
			return -1;
		}
		try {
			dao.insertProfession(pro);
		} catch (Exception e) {
			return -2;
		}
		return 0;
	}
	/**
	 * 按条件分页查询系
	 * @param clgId
	 * @param page
	 * @return
	 */
	public ArrayList<Department> getDepartmentBy(int clgId,int page){
		if(page<1){
			page=1;
		}
		int start=(page-1)*10;
		if(clgId==0){
			return dao.getDepartmentsByAll(start);
		}else{
			return dao.getDepartmentsByClgId(clgId, start);
		}
	}
	/**
	 * 按条件获取系总数
	 * @param clgId
	 * @return
	 */
	public int getDepartmentCountBy(int clgId){
		if(clgId==0){
			return dao.getDepartmentsCountByAll();
		}else{
			return dao.getDepartmentsCountByClgId(clgId);
		}
	}
	/**
	 * 修改一个系
	 * @param dep
	 * @return
	 */
	public int updateDepartment(Department dep){
		return dao.updateDepartment(dep);
	}
	/**
	 * 通过系编号读取系
	 * @param depNo
	 * @return
	 */
	public Department getDepartmentByDepNo(String depNo){
		return dao.getDepartmentByDepNo(depNo);
	}
	/**
	 * 删除系
	 * @param depId
	 * @return -1 系下面还有教师没有删除,-2系下面还有专业没有删除 0 成功
	 */
	public int deleteDepartment(int depId){
		if(dao.getTeacherCountByDepId(depId)>0){
			return -1;
		}
		if(dao.getProfessionsCountByDepId(depId)>0){
			return -2;
		}
		dao.deleteDepartment(depId);
		return 0;
	}
	/**
	 * 新建一个系
	 * @param dep
	 * @return -1 有相同no的系存在-2 存在同名系 -3 参数错误 0 成功
	 */
	public int insertDepartment(Department dep){
		if(dao.getDepartmentByDepNo(dep.getNo())!=null){
			return -1;
		}
		if(dao.getDepartmentByDepName(dep.getName())!=null){
			return -2;
		}
		try {
			dao.insertDepartment(dep);
		} catch (Exception e) {
			return -3;
		}
		return 0;
	}
	public Department getDepartmentByDepName(String depName){
		return dao.getDepartmentByDepName(depName);
	}
	/**
	 * 读取指定id的学院
	 * @param clgId
	 * @return
	 */
	public College getCollegeByClgId(int clgId){
		return dao.getCollegeByClgId(clgId);
	}
	/**
	 * 读取指定no的学院
	 * @param clgNo
	 * @return
	 */
	public College getCollegeByClgNo(String clgNo){
		return dao.getCollegeByClgNo(clgNo);
	}
	/**
	 * 修改一个学院 
	 * @param clg
	 * @return
	 */
	public int updateCollege(College clg){
		return dao.updateCollege(clg);
	}
	/**
	 * 删除一个学院
	 * @param clgId
	 * @return -1 学院下还有系 -2 学院下还有普通管理员 -3 仅仅只剩下一个学院了,不能删除
	 */
	public int deleteCollege(int clgId){
		if(dao.getDepartmentsCountByClgId(clgId)>0){
			return -1;
		}
		if(dao.getAdminCountByClgId(clgId)>0){
			return -2;
		}
		if(dao.getAllCollege().size()<=1){
			return -3;
		}
		dao.deleteCollege(clgId);
		return 0;
	}
	/**
	 * 增加一个学院
	 * @param clg
	 * @return -1 重复no -2 参数错误
	 */
	public int insertCollege(College clg){
		if(dao.getCollegeByClgNo(clg.getNo())!=null){
			return -1;
		}
		try {
			dao.insertCollege(clg);
		} catch (Exception e) {
			return -2;
		}
		return 0;
	}	
	/**
	 * 获取最小的学院id
	 * @return
	 */
	public int getMinCollegeId(){
		return dao.getMinCollegeId();
	}

	/**
	 * 获取某学院下id最小的系id
	 * @param clgId
	 * @return
	 */
	public int getMinDepIdOfCollege(int clgId){
		return dao.getMinDepIdOfCollege(clgId);
	}
	/**
	 * 获取某系下的教师个数
	 * @param depId
	 * @return
	 */
	public int getTeacherCountByDepId(int depId){
		if(depId==0){
			return 0;
		}
		return dao.getTeacherCountByDepId(depId);
	}
	/**
	 * 获取某系下的所有专业方向
	 * @param depId
	 * @return
	 */
	public ArrayList<ProfBranch> getAllBranchOfDepartment(int depId){
		return dao.getAllBranchOfDepartment(depId);
	}
}
